//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Tnb service.
///
///  Amazon Web Services Telco Network Builder (TNB) is a network automation service that helps you deploy and manage telecom networks. AWS TNB helps you with the lifecycle management of your telecommunication network functions throughout planning, deployment, and post-deployment activities.
public struct Tnb: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Tnb client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Tnb",
            serviceIdentifier: "tnb",
            serviceProtocol: .restjson,
            apiVersion: "2008-10-21",
            endpoint: endpoint,
            errorType: TnbErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Cancels a network operation. A network operation is any operation that is done to your network, such as network instance instantiation or termination.
    @Sendable
    @inlinable
    public func cancelSolNetworkOperation(_ input: CancelSolNetworkOperationInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "CancelSolNetworkOperation", 
            path: "/sol/nslcm/v1/ns_lcm_op_occs/{nsLcmOpOccId}/cancel", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels a network operation. A network operation is any operation that is done to your network, such as network instance instantiation or termination.
    ///
    /// Parameters:
    ///   - nsLcmOpOccId: The identifier of the network operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelSolNetworkOperation(
        nsLcmOpOccId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = CancelSolNetworkOperationInput(
            nsLcmOpOccId: nsLcmOpOccId
        )
        return try await self.cancelSolNetworkOperation(input, logger: logger)
    }

    /// Creates a function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network. For more information, see Function packages in the Amazon Web Services Telco Network Builder User Guide.  Creating a function package is the first step for creating a network in AWS TNB. This request creates an empty container with an ID. The next step is to upload the actual CSAR zip file into that empty container. To upload function package content, see PutSolFunctionPackageContent.
    @Sendable
    @inlinable
    public func createSolFunctionPackage(_ input: CreateSolFunctionPackageInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSolFunctionPackageOutput {
        try await self.client.execute(
            operation: "CreateSolFunctionPackage", 
            path: "/sol/vnfpkgm/v1/vnf_packages", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network. For more information, see Function packages in the Amazon Web Services Telco Network Builder User Guide.  Creating a function package is the first step for creating a network in AWS TNB. This request creates an empty container with an ID. The next step is to upload the actual CSAR zip file into that empty container. To upload function package content, see PutSolFunctionPackageContent.
    ///
    /// Parameters:
    ///   - tags: A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSolFunctionPackage(
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSolFunctionPackageOutput {
        let input = CreateSolFunctionPackageInput(
            tags: tags
        )
        return try await self.createSolFunctionPackage(input, logger: logger)
    }

    /// Creates a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. Creating a network instance is the third step after creating a network package. For more information about network instances, Network instances in the Amazon Web Services Telco Network Builder User Guide. Once you create a network instance, you can instantiate it. To instantiate a network, see InstantiateSolNetworkInstance.
    @Sendable
    @inlinable
    public func createSolNetworkInstance(_ input: CreateSolNetworkInstanceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSolNetworkInstanceOutput {
        try await self.client.execute(
            operation: "CreateSolNetworkInstance", 
            path: "/sol/nslcm/v1/ns_instances", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. Creating a network instance is the third step after creating a network package. For more information about network instances, Network instances in the Amazon Web Services Telco Network Builder User Guide. Once you create a network instance, you can instantiate it. To instantiate a network, see InstantiateSolNetworkInstance.
    ///
    /// Parameters:
    ///   - nsDescription: Network instance description.
    ///   - nsdInfoId: ID for network service descriptor.
    ///   - nsName: Network instance name.
    ///   - tags: A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSolNetworkInstance(
        nsDescription: String? = nil,
        nsdInfoId: String,
        nsName: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSolNetworkInstanceOutput {
        let input = CreateSolNetworkInstanceInput(
            nsDescription: nsDescription, 
            nsdInfoId: nsdInfoId, 
            nsName: nsName, 
            tags: tags
        )
        return try await self.createSolNetworkInstance(input, logger: logger)
    }

    /// Creates a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on. For more information, see Network instances in the Amazon Web Services Telco Network Builder User Guide.  A network package consists of a network service descriptor (NSD) file (required) and any additional files (optional), such as scripts specific to your needs. For example, if you have multiple function packages in your network package, you can use the NSD to define which network functions should run in certain VPCs, subnets, or EKS clusters. This request creates an empty network package container with an ID. Once you create a network package, you can upload the network package content using PutSolNetworkPackageContent.
    @Sendable
    @inlinable
    public func createSolNetworkPackage(_ input: CreateSolNetworkPackageInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSolNetworkPackageOutput {
        try await self.client.execute(
            operation: "CreateSolNetworkPackage", 
            path: "/sol/nsd/v1/ns_descriptors", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on. For more information, see Network instances in the Amazon Web Services Telco Network Builder User Guide.  A network package consists of a network service descriptor (NSD) file (required) and any additional files (optional), such as scripts specific to your needs. For example, if you have multiple function packages in your network package, you can use the NSD to define which network functions should run in certain VPCs, subnets, or EKS clusters. This request creates an empty network package container with an ID. Once you create a network package, you can upload the network package content using PutSolNetworkPackageContent.
    ///
    /// Parameters:
    ///   - tags: A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSolNetworkPackage(
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSolNetworkPackageOutput {
        let input = CreateSolNetworkPackageInput(
            tags: tags
        )
        return try await self.createSolNetworkPackage(input, logger: logger)
    }

    /// Deletes a function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network. To delete a function package, the package must be in a disabled state. To disable a function package, see UpdateSolFunctionPackage.
    @Sendable
    @inlinable
    public func deleteSolFunctionPackage(_ input: DeleteSolFunctionPackageInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteSolFunctionPackage", 
            path: "/sol/vnfpkgm/v1/vnf_packages/{vnfPkgId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network. To delete a function package, the package must be in a disabled state. To disable a function package, see UpdateSolFunctionPackage.
    ///
    /// Parameters:
    ///   - vnfPkgId: ID of the function package.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSolFunctionPackage(
        vnfPkgId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteSolFunctionPackageInput(
            vnfPkgId: vnfPkgId
        )
        return try await self.deleteSolFunctionPackage(input, logger: logger)
    }

    /// Deletes a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. To delete a network instance, the instance must be in a stopped or terminated state. To terminate a network instance, see TerminateSolNetworkInstance.
    @Sendable
    @inlinable
    public func deleteSolNetworkInstance(_ input: DeleteSolNetworkInstanceInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteSolNetworkInstance", 
            path: "/sol/nslcm/v1/ns_instances/{nsInstanceId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. To delete a network instance, the instance must be in a stopped or terminated state. To terminate a network instance, see TerminateSolNetworkInstance.
    ///
    /// Parameters:
    ///   - nsInstanceId: Network instance ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSolNetworkInstance(
        nsInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteSolNetworkInstanceInput(
            nsInstanceId: nsInstanceId
        )
        return try await self.deleteSolNetworkInstance(input, logger: logger)
    }

    /// Deletes network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on. To delete a network package, the package must be in a disable state. To disable a network package, see UpdateSolNetworkPackage.
    @Sendable
    @inlinable
    public func deleteSolNetworkPackage(_ input: DeleteSolNetworkPackageInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteSolNetworkPackage", 
            path: "/sol/nsd/v1/ns_descriptors/{nsdInfoId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on. To delete a network package, the package must be in a disable state. To disable a network package, see UpdateSolNetworkPackage.
    ///
    /// Parameters:
    ///   - nsdInfoId: ID of the network service descriptor in the network package.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSolNetworkPackage(
        nsdInfoId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteSolNetworkPackageInput(
            nsdInfoId: nsdInfoId
        )
        return try await self.deleteSolNetworkPackage(input, logger: logger)
    }

    /// Gets the details of a network function instance, including the instantiation state and metadata from the function package descriptor in the network function package. A network function instance is a function in a function package .
    @Sendable
    @inlinable
    public func getSolFunctionInstance(_ input: GetSolFunctionInstanceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSolFunctionInstanceOutput {
        try await self.client.execute(
            operation: "GetSolFunctionInstance", 
            path: "/sol/vnflcm/v1/vnf_instances/{vnfInstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the details of a network function instance, including the instantiation state and metadata from the function package descriptor in the network function package. A network function instance is a function in a function package .
    ///
    /// Parameters:
    ///   - vnfInstanceId: ID of the network function.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSolFunctionInstance(
        vnfInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSolFunctionInstanceOutput {
        let input = GetSolFunctionInstanceInput(
            vnfInstanceId: vnfInstanceId
        )
        return try await self.getSolFunctionInstance(input, logger: logger)
    }

    /// Gets the details of an individual function package, such as the operational state and whether the package is in use. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network..
    @Sendable
    @inlinable
    public func getSolFunctionPackage(_ input: GetSolFunctionPackageInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSolFunctionPackageOutput {
        try await self.client.execute(
            operation: "GetSolFunctionPackage", 
            path: "/sol/vnfpkgm/v1/vnf_packages/{vnfPkgId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the details of an individual function package, such as the operational state and whether the package is in use. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network..
    ///
    /// Parameters:
    ///   - vnfPkgId: ID of the function package.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSolFunctionPackage(
        vnfPkgId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSolFunctionPackageOutput {
        let input = GetSolFunctionPackageInput(
            vnfPkgId: vnfPkgId
        )
        return try await self.getSolFunctionPackage(input, logger: logger)
    }

    /// Gets the contents of a function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    @Sendable
    @inlinable
    public func getSolFunctionPackageContent(_ input: GetSolFunctionPackageContentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSolFunctionPackageContentOutput {
        try await self.client.execute(
            operation: "GetSolFunctionPackageContent", 
            path: "/sol/vnfpkgm/v1/vnf_packages/{vnfPkgId}/package_content", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the contents of a function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    ///
    /// Parameters:
    ///   - accept: The format of the package that you want to download from the function packages.
    ///   - vnfPkgId: ID of the function package.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSolFunctionPackageContent(
        accept: PackageContentType,
        vnfPkgId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSolFunctionPackageContentOutput {
        let input = GetSolFunctionPackageContentInput(
            accept: accept, 
            vnfPkgId: vnfPkgId
        )
        return try await self.getSolFunctionPackageContent(input, logger: logger)
    }

    /// Gets a function package descriptor in a function package. A function package descriptor is a .yaml file in a function package that uses the TOSCA standard to describe how the network function in the function package should run on your network. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    @Sendable
    @inlinable
    public func getSolFunctionPackageDescriptor(_ input: GetSolFunctionPackageDescriptorInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSolFunctionPackageDescriptorOutput {
        try await self.client.execute(
            operation: "GetSolFunctionPackageDescriptor", 
            path: "/sol/vnfpkgm/v1/vnf_packages/{vnfPkgId}/vnfd", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a function package descriptor in a function package. A function package descriptor is a .yaml file in a function package that uses the TOSCA standard to describe how the network function in the function package should run on your network. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    ///
    /// Parameters:
    ///   - accept: Indicates which content types, expressed as MIME types, the client is able to understand.
    ///   - vnfPkgId: ID of the function package.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSolFunctionPackageDescriptor(
        accept: DescriptorContentType,
        vnfPkgId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSolFunctionPackageDescriptorOutput {
        let input = GetSolFunctionPackageDescriptorInput(
            accept: accept, 
            vnfPkgId: vnfPkgId
        )
        return try await self.getSolFunctionPackageDescriptor(input, logger: logger)
    }

    /// Gets the details of the network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
    @Sendable
    @inlinable
    public func getSolNetworkInstance(_ input: GetSolNetworkInstanceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSolNetworkInstanceOutput {
        try await self.client.execute(
            operation: "GetSolNetworkInstance", 
            path: "/sol/nslcm/v1/ns_instances/{nsInstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the details of the network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
    ///
    /// Parameters:
    ///   - nsInstanceId: ID of the network instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSolNetworkInstance(
        nsInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSolNetworkInstanceOutput {
        let input = GetSolNetworkInstanceInput(
            nsInstanceId: nsInstanceId
        )
        return try await self.getSolNetworkInstance(input, logger: logger)
    }

    /// Gets the details of a network operation, including the tasks involved in the network operation and the status of the tasks. A network operation is any operation that is done to your network, such as network instance instantiation or termination.
    @Sendable
    @inlinable
    public func getSolNetworkOperation(_ input: GetSolNetworkOperationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSolNetworkOperationOutput {
        try await self.client.execute(
            operation: "GetSolNetworkOperation", 
            path: "/sol/nslcm/v1/ns_lcm_op_occs/{nsLcmOpOccId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the details of a network operation, including the tasks involved in the network operation and the status of the tasks. A network operation is any operation that is done to your network, such as network instance instantiation or termination.
    ///
    /// Parameters:
    ///   - nsLcmOpOccId: The identifier of the network operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSolNetworkOperation(
        nsLcmOpOccId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSolNetworkOperationOutput {
        let input = GetSolNetworkOperationInput(
            nsLcmOpOccId: nsLcmOpOccId
        )
        return try await self.getSolNetworkOperation(input, logger: logger)
    }

    /// Gets the details of a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    @Sendable
    @inlinable
    public func getSolNetworkPackage(_ input: GetSolNetworkPackageInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSolNetworkPackageOutput {
        try await self.client.execute(
            operation: "GetSolNetworkPackage", 
            path: "/sol/nsd/v1/ns_descriptors/{nsdInfoId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the details of a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    ///
    /// Parameters:
    ///   - nsdInfoId: ID of the network service descriptor in the network package.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSolNetworkPackage(
        nsdInfoId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSolNetworkPackageOutput {
        let input = GetSolNetworkPackageInput(
            nsdInfoId: nsdInfoId
        )
        return try await self.getSolNetworkPackage(input, logger: logger)
    }

    /// Gets the contents of a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    @Sendable
    @inlinable
    public func getSolNetworkPackageContent(_ input: GetSolNetworkPackageContentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSolNetworkPackageContentOutput {
        try await self.client.execute(
            operation: "GetSolNetworkPackageContent", 
            path: "/sol/nsd/v1/ns_descriptors/{nsdInfoId}/nsd_content", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the contents of a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    ///
    /// Parameters:
    ///   - accept: The format of the package you want to download from the network package.
    ///   - nsdInfoId: ID of the network service descriptor in the network package.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSolNetworkPackageContent(
        accept: PackageContentType,
        nsdInfoId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSolNetworkPackageContentOutput {
        let input = GetSolNetworkPackageContentInput(
            accept: accept, 
            nsdInfoId: nsdInfoId
        )
        return try await self.getSolNetworkPackageContent(input, logger: logger)
    }

    /// Gets the content of the network service descriptor. A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network functions on.
    @Sendable
    @inlinable
    public func getSolNetworkPackageDescriptor(_ input: GetSolNetworkPackageDescriptorInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSolNetworkPackageDescriptorOutput {
        try await self.client.execute(
            operation: "GetSolNetworkPackageDescriptor", 
            path: "/sol/nsd/v1/ns_descriptors/{nsdInfoId}/nsd", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the content of the network service descriptor. A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network functions on.
    ///
    /// Parameters:
    ///   - nsdInfoId: ID of the network service descriptor in the network package.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSolNetworkPackageDescriptor(
        nsdInfoId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSolNetworkPackageDescriptorOutput {
        let input = GetSolNetworkPackageDescriptorInput(
            nsdInfoId: nsdInfoId
        )
        return try await self.getSolNetworkPackageDescriptor(input, logger: logger)
    }

    /// Instantiates a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. Before you can instantiate a network instance, you have to create a network instance. For more information, see CreateSolNetworkInstance.
    @Sendable
    @inlinable
    public func instantiateSolNetworkInstance(_ input: InstantiateSolNetworkInstanceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> InstantiateSolNetworkInstanceOutput {
        try await self.client.execute(
            operation: "InstantiateSolNetworkInstance", 
            path: "/sol/nslcm/v1/ns_instances/{nsInstanceId}/instantiate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Instantiates a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. Before you can instantiate a network instance, you have to create a network instance. For more information, see CreateSolNetworkInstance.
    ///
    /// Parameters:
    ///   - additionalParamsForNs: Provides values for the configurable properties.
    ///   - dryRun: A check for whether you have the required permissions for the action without actually making the request  and provides an error response. If you have the required permissions, the error response is DryRunOperation.  Otherwise, it is UnauthorizedOperation.
    ///   - nsInstanceId: ID of the network instance.
    ///   - tags: A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. When you use this API, the tags are only applied to the network operation that is created. These tags are not applied to the network instance. Use tags to search and filter your resources or track your Amazon Web Services costs.
    ///   - logger: Logger use during operation
    @inlinable
    public func instantiateSolNetworkInstance(
        additionalParamsForNs: AWSDocument? = nil,
        dryRun: Bool? = nil,
        nsInstanceId: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> InstantiateSolNetworkInstanceOutput {
        let input = InstantiateSolNetworkInstanceInput(
            additionalParamsForNs: additionalParamsForNs, 
            dryRun: dryRun, 
            nsInstanceId: nsInstanceId, 
            tags: tags
        )
        return try await self.instantiateSolNetworkInstance(input, logger: logger)
    }

    /// Lists network function instances. A network function instance is a function in a function package .
    @Sendable
    @inlinable
    public func listSolFunctionInstances(_ input: ListSolFunctionInstancesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSolFunctionInstancesOutput {
        try await self.client.execute(
            operation: "ListSolFunctionInstances", 
            path: "/sol/vnflcm/v1/vnf_instances", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists network function instances. A network function instance is a function in a function package .
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSolFunctionInstances(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSolFunctionInstancesOutput {
        let input = ListSolFunctionInstancesInput(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSolFunctionInstances(input, logger: logger)
    }

    /// Lists information about function packages. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    @Sendable
    @inlinable
    public func listSolFunctionPackages(_ input: ListSolFunctionPackagesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSolFunctionPackagesOutput {
        try await self.client.execute(
            operation: "ListSolFunctionPackages", 
            path: "/sol/vnfpkgm/v1/vnf_packages", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists information about function packages. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSolFunctionPackages(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSolFunctionPackagesOutput {
        let input = ListSolFunctionPackagesInput(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSolFunctionPackages(input, logger: logger)
    }

    /// Lists your network instances. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
    @Sendable
    @inlinable
    public func listSolNetworkInstances(_ input: ListSolNetworkInstancesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSolNetworkInstancesOutput {
        try await self.client.execute(
            operation: "ListSolNetworkInstances", 
            path: "/sol/nslcm/v1/ns_instances", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists your network instances. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSolNetworkInstances(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSolNetworkInstancesOutput {
        let input = ListSolNetworkInstancesInput(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSolNetworkInstances(input, logger: logger)
    }

    /// Lists details for a network operation, including when the operation started and the status of the operation. A network operation is any operation that is done to your network, such as network instance instantiation or termination.
    @Sendable
    @inlinable
    public func listSolNetworkOperations(_ input: ListSolNetworkOperationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSolNetworkOperationsOutput {
        try await self.client.execute(
            operation: "ListSolNetworkOperations", 
            path: "/sol/nslcm/v1/ns_lcm_op_occs", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists details for a network operation, including when the operation started and the status of the operation. A network operation is any operation that is done to your network, such as network instance instantiation or termination.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - nextToken: The token for the next page of results.
    ///   - nsInstanceId: Network instance id filter, to retrieve network operations associated to a network instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSolNetworkOperations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        nsInstanceId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSolNetworkOperationsOutput {
        let input = ListSolNetworkOperationsInput(
            maxResults: maxResults, 
            nextToken: nextToken, 
            nsInstanceId: nsInstanceId
        )
        return try await self.listSolNetworkOperations(input, logger: logger)
    }

    /// Lists network packages. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    @Sendable
    @inlinable
    public func listSolNetworkPackages(_ input: ListSolNetworkPackagesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSolNetworkPackagesOutput {
        try await self.client.execute(
            operation: "ListSolNetworkPackages", 
            path: "/sol/nsd/v1/ns_descriptors", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists network packages. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSolNetworkPackages(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSolNetworkPackagesOutput {
        let input = ListSolNetworkPackagesInput(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSolNetworkPackages(input, logger: logger)
    }

    /// Lists tags for AWS TNB resources.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceOutput {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists tags for AWS TNB resources.
    ///
    /// Parameters:
    ///   - resourceArn: Resource ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceOutput {
        let input = ListTagsForResourceInput(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Uploads the contents of a function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    @Sendable
    @inlinable
    public func putSolFunctionPackageContent(_ input: PutSolFunctionPackageContentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PutSolFunctionPackageContentOutput {
        try await self.client.execute(
            operation: "PutSolFunctionPackageContent", 
            path: "/sol/vnfpkgm/v1/vnf_packages/{vnfPkgId}/package_content", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Uploads the contents of a function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    ///
    /// Parameters:
    ///   - contentType: Function package content type.
    ///   - file: Function package file.
    ///   - vnfPkgId: Function package ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func putSolFunctionPackageContent(
        contentType: PackageContentType? = nil,
        file: AWSHTTPBody,
        vnfPkgId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutSolFunctionPackageContentOutput {
        let input = PutSolFunctionPackageContentInput(
            contentType: contentType, 
            file: file, 
            vnfPkgId: vnfPkgId
        )
        return try await self.putSolFunctionPackageContent(input, logger: logger)
    }

    /// Uploads the contents of a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    @Sendable
    @inlinable
    public func putSolNetworkPackageContent(_ input: PutSolNetworkPackageContentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PutSolNetworkPackageContentOutput {
        try await self.client.execute(
            operation: "PutSolNetworkPackageContent", 
            path: "/sol/nsd/v1/ns_descriptors/{nsdInfoId}/nsd_content", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Uploads the contents of a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    ///
    /// Parameters:
    ///   - contentType: Network package content type.
    ///   - file: Network package file.
    ///   - nsdInfoId: Network service descriptor info ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func putSolNetworkPackageContent(
        contentType: PackageContentType? = nil,
        file: AWSHTTPBody,
        nsdInfoId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutSolNetworkPackageContentOutput {
        let input = PutSolNetworkPackageContentInput(
            contentType: contentType, 
            file: file, 
            nsdInfoId: nsdInfoId
        )
        return try await self.putSolNetworkPackageContent(input, logger: logger)
    }

    /// Tags an AWS TNB resource. A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceOutput {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Tags an AWS TNB resource. A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
    ///
    /// Parameters:
    ///   - resourceArn: Resource ARN.
    ///   - tags: A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceOutput {
        let input = TagResourceInput(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Terminates a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. You must terminate a network instance before you can delete it.
    @Sendable
    @inlinable
    public func terminateSolNetworkInstance(_ input: TerminateSolNetworkInstanceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> TerminateSolNetworkInstanceOutput {
        try await self.client.execute(
            operation: "TerminateSolNetworkInstance", 
            path: "/sol/nslcm/v1/ns_instances/{nsInstanceId}/terminate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Terminates a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. You must terminate a network instance before you can delete it.
    ///
    /// Parameters:
    ///   - nsInstanceId: ID of the network instance.
    ///   - tags: A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. When you use this API, the tags are only applied to the network operation that is created. These tags are not applied to the network instance. Use tags to search and filter your resources or track your Amazon Web Services costs.
    ///   - logger: Logger use during operation
    @inlinable
    public func terminateSolNetworkInstance(
        nsInstanceId: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TerminateSolNetworkInstanceOutput {
        let input = TerminateSolNetworkInstanceInput(
            nsInstanceId: nsInstanceId, 
            tags: tags
        )
        return try await self.terminateSolNetworkInstance(input, logger: logger)
    }

    /// Untags an AWS TNB resource. A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceOutput {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Untags an AWS TNB resource. A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
    ///
    /// Parameters:
    ///   - resourceArn: Resource ARN.
    ///   - tagKeys: Tag keys.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceOutput {
        let input = UntagResourceInput(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the operational state of function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    @Sendable
    @inlinable
    public func updateSolFunctionPackage(_ input: UpdateSolFunctionPackageInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSolFunctionPackageOutput {
        try await self.client.execute(
            operation: "UpdateSolFunctionPackage", 
            path: "/sol/vnfpkgm/v1/vnf_packages/{vnfPkgId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the operational state of function package. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    ///
    /// Parameters:
    ///   - operationalState: Operational state of the function package.
    ///   - vnfPkgId: ID of the function package.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSolFunctionPackage(
        operationalState: OperationalState,
        vnfPkgId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSolFunctionPackageOutput {
        let input = UpdateSolFunctionPackageInput(
            operationalState: operationalState, 
            vnfPkgId: vnfPkgId
        )
        return try await self.updateSolFunctionPackage(input, logger: logger)
    }

    /// Update a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. Choose the updateType parameter to target the necessary update of the network instance.
    @Sendable
    @inlinable
    public func updateSolNetworkInstance(_ input: UpdateSolNetworkInstanceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSolNetworkInstanceOutput {
        try await self.client.execute(
            operation: "UpdateSolNetworkInstance", 
            path: "/sol/nslcm/v1/ns_instances/{nsInstanceId}/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update a network instance. A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed. Choose the updateType parameter to target the necessary update of the network instance.
    ///
    /// Parameters:
    ///   - modifyVnfInfoData: Identifies the network function information parameters and/or the configurable properties of the network function to be modified. Include this property only if the update type is MODIFY_VNF_INFORMATION.
    ///   - nsInstanceId: ID of the network instance.
    ///   - tags: A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. When you use this API, the tags are only applied to the network operation that is created. These tags are not applied to the network instance. Use tags to search and filter your resources or track your Amazon Web Services costs.
    ///   - updateNs: Identifies the network service descriptor and the configurable properties of the descriptor, to be used for the update. Include this property only if the update type is UPDATE_NS.
    ///   - updateType: The type of update.   Use the MODIFY_VNF_INFORMATION update type, to update a specific network function configuration, in the network instance.   Use the UPDATE_NS update type, to update the network instance to a new network service descriptor.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSolNetworkInstance(
        modifyVnfInfoData: UpdateSolNetworkModify? = nil,
        nsInstanceId: String,
        tags: [String: String]? = nil,
        updateNs: UpdateSolNetworkServiceData? = nil,
        updateType: UpdateSolNetworkType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSolNetworkInstanceOutput {
        let input = UpdateSolNetworkInstanceInput(
            modifyVnfInfoData: modifyVnfInfoData, 
            nsInstanceId: nsInstanceId, 
            tags: tags, 
            updateNs: updateNs, 
            updateType: updateType
        )
        return try await self.updateSolNetworkInstance(input, logger: logger)
    }

    /// Updates the operational state of a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on. A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network functions on.
    @Sendable
    @inlinable
    public func updateSolNetworkPackage(_ input: UpdateSolNetworkPackageInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSolNetworkPackageOutput {
        try await self.client.execute(
            operation: "UpdateSolNetworkPackage", 
            path: "/sol/nsd/v1/ns_descriptors/{nsdInfoId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the operational state of a network package. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on. A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network functions on.
    ///
    /// Parameters:
    ///   - nsdInfoId: ID of the network service descriptor in the network package.
    ///   - nsdOperationalState: Operational state of the network service descriptor in the network package.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSolNetworkPackage(
        nsdInfoId: String,
        nsdOperationalState: NsdOperationalState,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSolNetworkPackageOutput {
        let input = UpdateSolNetworkPackageInput(
            nsdInfoId: nsdInfoId, 
            nsdOperationalState: nsdOperationalState
        )
        return try await self.updateSolNetworkPackage(input, logger: logger)
    }

    /// Validates function package content. This can be used as a dry run before uploading function package content with PutSolFunctionPackageContent. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    @Sendable
    @inlinable
    public func validateSolFunctionPackageContent(_ input: ValidateSolFunctionPackageContentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ValidateSolFunctionPackageContentOutput {
        try await self.client.execute(
            operation: "ValidateSolFunctionPackageContent", 
            path: "/sol/vnfpkgm/v1/vnf_packages/{vnfPkgId}/package_content/validate", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Validates function package content. This can be used as a dry run before uploading function package content with PutSolFunctionPackageContent. A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.
    ///
    /// Parameters:
    ///   - contentType: Function package content type.
    ///   - file: Function package file.
    ///   - vnfPkgId: Function package ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func validateSolFunctionPackageContent(
        contentType: PackageContentType? = nil,
        file: AWSHTTPBody,
        vnfPkgId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ValidateSolFunctionPackageContentOutput {
        let input = ValidateSolFunctionPackageContentInput(
            contentType: contentType, 
            file: file, 
            vnfPkgId: vnfPkgId
        )
        return try await self.validateSolFunctionPackageContent(input, logger: logger)
    }

    /// Validates network package content. This can be used as a dry run before uploading network package content with PutSolNetworkPackageContent. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    @Sendable
    @inlinable
    public func validateSolNetworkPackageContent(_ input: ValidateSolNetworkPackageContentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ValidateSolNetworkPackageContentOutput {
        try await self.client.execute(
            operation: "ValidateSolNetworkPackageContent", 
            path: "/sol/nsd/v1/ns_descriptors/{nsdInfoId}/nsd_content/validate", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Validates network package content. This can be used as a dry run before uploading network package content with PutSolNetworkPackageContent. A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.
    ///
    /// Parameters:
    ///   - contentType: Network package content type.
    ///   - file: Network package file.
    ///   - nsdInfoId: Network service descriptor file.
    ///   - logger: Logger use during operation
    @inlinable
    public func validateSolNetworkPackageContent(
        contentType: PackageContentType? = nil,
        file: AWSHTTPBody,
        nsdInfoId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ValidateSolNetworkPackageContentOutput {
        let input = ValidateSolNetworkPackageContentInput(
            contentType: contentType, 
            file: file, 
            nsdInfoId: nsdInfoId
        )
        return try await self.validateSolNetworkPackageContent(input, logger: logger)
    }
}

extension Tnb {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Tnb, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Tnb {
    /// Return PaginatorSequence for operation ``listSolFunctionInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolFunctionInstancesPaginator(
        _ input: ListSolFunctionInstancesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSolFunctionInstancesInput, ListSolFunctionInstancesOutput> {
        return .init(
            input: input,
            command: self.listSolFunctionInstances,
            inputKey: \ListSolFunctionInstancesInput.nextToken,
            outputKey: \ListSolFunctionInstancesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSolFunctionInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolFunctionInstancesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSolFunctionInstancesInput, ListSolFunctionInstancesOutput> {
        let input = ListSolFunctionInstancesInput(
            maxResults: maxResults
        )
        return self.listSolFunctionInstancesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSolFunctionPackages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolFunctionPackagesPaginator(
        _ input: ListSolFunctionPackagesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSolFunctionPackagesInput, ListSolFunctionPackagesOutput> {
        return .init(
            input: input,
            command: self.listSolFunctionPackages,
            inputKey: \ListSolFunctionPackagesInput.nextToken,
            outputKey: \ListSolFunctionPackagesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSolFunctionPackages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolFunctionPackagesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSolFunctionPackagesInput, ListSolFunctionPackagesOutput> {
        let input = ListSolFunctionPackagesInput(
            maxResults: maxResults
        )
        return self.listSolFunctionPackagesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSolNetworkInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolNetworkInstancesPaginator(
        _ input: ListSolNetworkInstancesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSolNetworkInstancesInput, ListSolNetworkInstancesOutput> {
        return .init(
            input: input,
            command: self.listSolNetworkInstances,
            inputKey: \ListSolNetworkInstancesInput.nextToken,
            outputKey: \ListSolNetworkInstancesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSolNetworkInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolNetworkInstancesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSolNetworkInstancesInput, ListSolNetworkInstancesOutput> {
        let input = ListSolNetworkInstancesInput(
            maxResults: maxResults
        )
        return self.listSolNetworkInstancesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSolNetworkOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolNetworkOperationsPaginator(
        _ input: ListSolNetworkOperationsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSolNetworkOperationsInput, ListSolNetworkOperationsOutput> {
        return .init(
            input: input,
            command: self.listSolNetworkOperations,
            inputKey: \ListSolNetworkOperationsInput.nextToken,
            outputKey: \ListSolNetworkOperationsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSolNetworkOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - nsInstanceId: Network instance id filter, to retrieve network operations associated to a network instance.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolNetworkOperationsPaginator(
        maxResults: Int? = nil,
        nsInstanceId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSolNetworkOperationsInput, ListSolNetworkOperationsOutput> {
        let input = ListSolNetworkOperationsInput(
            maxResults: maxResults, 
            nsInstanceId: nsInstanceId
        )
        return self.listSolNetworkOperationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSolNetworkPackages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolNetworkPackagesPaginator(
        _ input: ListSolNetworkPackagesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSolNetworkPackagesInput, ListSolNetworkPackagesOutput> {
        return .init(
            input: input,
            command: self.listSolNetworkPackages,
            inputKey: \ListSolNetworkPackagesInput.nextToken,
            outputKey: \ListSolNetworkPackagesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSolNetworkPackages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to include in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSolNetworkPackagesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSolNetworkPackagesInput, ListSolNetworkPackagesOutput> {
        let input = ListSolNetworkPackagesInput(
            maxResults: maxResults
        )
        return self.listSolNetworkPackagesPaginator(input, logger: logger)
    }
}

extension Tnb.ListSolFunctionInstancesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Tnb.ListSolFunctionInstancesInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Tnb.ListSolFunctionPackagesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Tnb.ListSolFunctionPackagesInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Tnb.ListSolNetworkInstancesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Tnb.ListSolNetworkInstancesInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Tnb.ListSolNetworkOperationsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Tnb.ListSolNetworkOperationsInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            nsInstanceId: self.nsInstanceId
        )
    }
}

extension Tnb.ListSolNetworkPackagesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Tnb.ListSolNetworkPackagesInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
